#import reversi
#valores del tablero -1 negro, 0 vacio, 1 blanco
#turno = -1 negro 1 blanco

profundidad=3


def utility(tablero):
    """Devuelve la utilidad (int) de cada jugada dado un tablero (int)[8][8]."""
    blancas = 0
    negras = 0
    for i in range(0, 8):
        for j in range(0, 8):
            if (tablero[i][j] == 1): # blancas
                blancas -= 10
            elif (tablero[i][j] == -1): # negras
                negras += 10
    resultado = blancas + negras
    
    return resultado

def legal_moves(tablero, color, coorx, coory):
    """Busca los pivotes de una posicion (coordenadas x,y) en el tablero que 
    recibe, con el jugador
    tablero: int [8][8], color:el color del cual se busca el pivote (int)
    coorx: posicion x del tablero (int), coory:...(int)"""
    f = 0
    c = 0
    piv = []
    #El doble for es para buscar si hay una ficha del jugador contaraio en las 8 posiciones al rededor de la posicion a colocar
    for k in range(-1, 2):
        for l in range (-1,2):
            #Para evitar que ambos indices sean cero y queden en loop infinito
            if (k != 0) or (l != 0):
                f = coorx + k
                c = coory + l
                #Para evitar salir del tablero
                if  ((f >= 0) and (f < 8) and (c >= 0) and (c < 8)):
                    if not (tablero[f][c] == 0) and not (tablero[f][c] == color):
                        while ((f >= 0) and (f < 8) and (c >= 0) and (c < 8)):
                            #si encuentra una una ficha de ese color es un pivote, almacena y sale del while
                            if tablero[f][c] == color:
                                piv.append((f,c))
                                break
                            elif tablero[f][c]==0:
                                break
                            f = f + k
                            c = c + l
    
    return piv
    

def terminal_test(tablero):
    """Revisa si cualquiera de los 2 jugadores tiene alguna jugada disponible, si es asi
    devuelve 0 en caso contrario devuelve 1"""
    if (realizar_jugada(tablero, 1) or realizar_jugada(tablero, -1)):
        return 0
        
    else:
        return 1
        

def realizar_jugada(tablero, turno):
    """Busca las posibles jugadas en todo el tablero para realizar
    devuelve un diccionario con las coordenadas (keys) y la lista de pivotes 
    de sus correspondientes posiciones"""
    aux=[]
    sucesor={}
    for i in range(0,8):
            for j in range(0,8):
                if(tablero[i][j]==0):
                    aux=legal_moves(tablero, turno, i, j)
                    if(aux):
                        sucesor.update({(i,j):aux})

    return sucesor  
    
def contar_fichas(tablero):
    """Cuenta las fichas para el resumen al final de la partida"""
    blancas=0
    negras=0
    for i in range(0,8):
        for j in range(0,8):
            if (tablero[i][j]==1):
                blancas+=1
            elif (tablero[i][j]==-1):
                negras+=1
                
    print('blancas:',blancas, 'negras:', negras)
    pass

def make_move(tablero,turno,move):
    """Realiza la jugada en el tablero con el jugador que recibe como parametro
    tablero: el tablero actual
    turno(int) el jugador que realiza la jugada
    move{coordenadaa:pivotes}: diccionario con la coordenada en donde se va a jugar y los pivortes respectivos"""
    posicion=move.keys().pop()
    while(len(move[posicion])):
        
        pivote=move[posicion].pop() 
        numFilas=pivote[0] - posicion[0]
        numCol=pivote[1] - posicion[1]
        
        incFila = 0
        incCol = 0
        #ve la direccion hacia donde va a voltear las fichas
        if(numFilas):
            incFila = numFilas / abs(numFilas)
            
        if (numCol):
            incCol = numCol / abs(numCol)
        #Calcula la cantidad de veces que se dara vueltas la fichas
        numVolteos = max(abs(numFilas), abs(numCol))
        f = posicion[0]
        c = posicion[1]
        
        for i in range(0,numVolteos):
            if (tablero[f][c]== 0):
                tablero[f][c]=turno
            elif(tablero[f][c]==1):
                tablero[f][c]=turno
            else:
                tablero[f][c]=turno
            c += incCol
            f += incFila
    
    pass


def negamax(tab, jugador, limite):
    """int [7][7] tablero : el tablero actual de juego para realizar el analisis
    int jugador: el jugador que realiza el movimiento
    int limite: el limite de la profundidad del arbol a para realizar la busqueda"""
    bandera = 0
    if(profundidad < limite or terminal_test(tab)):
        return(utility(tab),0)
    else:
        sucesor=realizar_jugada(tab, jugador)
        for i in sucesor:
            resultado=-1.0e350#infinito
            #hace una copia del tablero
            bandera = 1
            nuevotablero = [[], [], [], [], [], [], [], []]            
            clonar_tablero(tab, nuevotablero)
            make_move(nuevotablero, jugador,{i:sucesor.get(i)})
            #se hace la llamada recursiva
            resultado=max(resultado,-(negamax(nuevotablero,(jugador*-1), (limite+1)))[0])
#        else:
#            i=0
#            resultado=-1.0e350#infinito
        if (bandera == 1):
            return (resultado, i)
        else:
            resultado=-1.0e350#infinito
            i = 0
            return (resultado, i)
    return (resultado,i)
    

def clonar_tablero(tablero, tablero_copiado):
    """Recibe un tablero y devuelve una copia del mismo"""
    for i in range (0, 8):
        for j in range (0, 8):
            tablero_copiado[i].append(tablero[i][j])
        
def imprimir_tablero(tab):
    #print '    0  1  2  3  4  5  6  7'
    print '    A  B  C  D  E  F  G  H'
    print '--------------------------'
    for i in range(0, 8):
        print i+1,'|',
        for j in range (0, 8):
            if (tab[i][j]== 0):
                print '. ',
            elif(tab[i][j]== 1):
                print 'B ',
            else:
                print 'N ',
        print "\n"
    
    pass
    
def imprimir_coordenadas(y):
    if y==0:
        return 'A'
    elif y==1:
        return 'B'
    elif y==2:
        return 'C'
    elif y==3:
        return 'D'
    elif y==4:
        return 'E'
    elif y==5:
        return 'F'
    elif y==6:
        return 'G'
    elif y==7:
        return 'H'
        
def convertir_coord(y):
    y=y.upper()
    if y =='A':
        return 0
    elif y == 'B':
        return 1
    elif y == 'C':
        return 2
    elif y == 'D':
        return 3
    elif y == 'E':
        return 4
    elif y == 'F':
        return 5
    elif y == 'G':
        return 6
    elif y == 'H':
        return 7
    
if __name__ == "__main__":
    contador=0
    turno=-1
    tablero = [[0 for i in range(8)] for i in range(8)]
    for i in range(0,8):
        for j in range(0,8):
            tablero[i][j] = 0
    tablero[3][3] = 1
    tablero[3][4] = -1
    tablero[4][3] = -1
    tablero[4][4] = 1
        

    while(not terminal_test(tablero)):        
        sucesor=realizar_jugada(tablero, turno)
        
        if (sucesor):
            if(turno==-1):
                movimiento=negamax(tablero, -1,0)
                print movimiento[1][0]+1, imprimir_coordenadas (movimiento[1][1])
                pivotes=legal_moves(tablero,-1,movimiento[1][0],movimiento[1][1])
                make_move(tablero,-1,{movimiento[1]:pivotes})
                turno*= -1
                imprimir_tablero(tablero)
                
            else:
            
                piv=[1]
                while(piv):
                    print 'Jugada humano fila columna'
                    jugada_humano=raw_input()
                    try:
                        x=int(jugada_humano[0])-1
                        y=convertir_coord(jugada_humano[2])
                    except:
                        print 'Vuelva a intentar ingresar los valores'
                        continue
                    print (x,y)
                    piv=legal_moves(tablero, turno, x, y)
                    if(piv):
                        make_move(tablero,turno,{(x,y):piv})
                        imprimir_tablero(tablero)
                        turno*= -1
                    else:
                        print 'NO ES UNA JUGADA VALIDA'
                
        else:
            print 'HOLA2'
            turno*= -1
            
        
        
    contar_fichas(tablero)
    pass


    

